home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / queues.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  13.3 KB  |  221 lines
  1. DEFINITION MODULE  Queues;
  2.  
  3. (*****************************************************************************)
  4. (* Dieses Modul enthaelt Prozeduren zur Erzeugung und Verwaltung einer Queue *)
  5. (* (FIFO - Warteschlange ). Die Queueoperationen sind nicht an einen bestimm-*)
  6. (* ten Datentyp gebunden, d.h. aber auch, dass keine Typueberpruefung - we-  *)
  7. (* der zur Uebersetzungszeit noch zur Laufzeit - vorgenommen wird.           *)
  8. (* Wird jedoch zur Laufzeit ein Parameter mit anderem Speicherbedarf benutzt *)
  9. (* als bei der Queuedefinition angegeben wurde, gibt es einen Fehler         *)
  10. (* ( --> sizeErr ).                                                          *)
  11. (*                                                                           *)
  12. (* Da Warteschlangen wohl hauptsaechlich bei der Prozessverwaltung eingesetzt*)
  13. (* werden und die Prozessbeschreibungsbloecke evtl. in mehreren Warteschlan- *)
  14. (* gen oder anderen Statusbloecken stehen, ist es wichtig, sicherzustellen,  *)
  15. (* dass bei einem bestimmten Prozess immer mit demselben Prozessbeschrei-    *)
  16. (* bungsblock gearbeitet wird und nicht mit irgendeiner Kopie. In diesem Fall*)
  17. (* benutzt man als Parameter nur die Adressen der eigentlichen Elemente,     *)
  18. (* die so auch in unterschiedlichen Warteschlangen stehen koennen aber in    *)
  19. (* Wirklichkeit nur einmal vorhanden sind.                                   *)
  20. (* Wenn also ein Element veraendert wird, so ist diese Aenderung auch in     *)
  21. (* allen anderen Warteschlangen bekannt, in denen dieses Element steht, da   *)
  22. (* nur Verweise auf die Elemente gespeichert werden; das funktioniert so-    *)
  23. (* lange, wie das Element selber an einem festen Platz steht; wird also z.B. *)
  24. (* bei dynamischer Speicheranforderung fuer einen Prozessblock, der Speicher *)
  25. (* nach Prozessende wieder freigegeben, so muessen VORHER die Verweise auf   *)
  26. (* diesen Block in saemtlichen Queues mittels "Remove" entfernt werden, da   *)
  27. (* sonst Referenzen auf undefinierte Speicherbereiche bestehen !             *)
  28. (*                                                                           *)
  29. (* Alle Prozeduren pruefen, ob die Queue, die ihnen uebergeben wird, einen   *)
  30. (* undefinierten Wert hat. ( --> defErr ).                                   *)
  31. (*                                                                           *)
  32. (* Wird ein beliebiger Fehler erkannt, wird dies ueber den Parameter <done>  *)
  33. (* mitgeteilt; eine detailliertere Fehlermeldung erhaelt man ueber die Proze-*)
  34. (* dur "LastQueueResult". Auf Wunsch kann auch mit "AssignQueueHandler" eine *)
  35. (* automatische Fehlerbehandlung durch das Modul erfolgen.                   *)
  36. (*                                                                           *)
  37. (* Wegen der Pruefung auf undefinierte Queue muessen saemtliche Parameter    *)
  38. (* vom Typ Queue als VAR-Parameter uebergeben werden, obwohl sie manchmal    *)
  39. (* nur Eingangsparameter sind ( siehe Kommentar ).                           *)
  40. (*___________________________________________________________________________*)
  41. (*   24-Feb-90 , Holger Kleinschmidt                                         *)
  42. (*****************************************************************************)
  43.  
  44.  
  45. FROM  SYSTEM  IMPORT  (* TYPE *) ADDRESS, BYTE;
  46.  
  47. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  48.  
  49. TYPE
  50.       Queue;
  51.  
  52.       QueueResult  = ( queueOk, defErr, sizeErr, noMem, queueEmpty );
  53.  
  54.       QueueHandler = PROCEDURE ((* EIN  proc *) ARRAY OF CHAR,
  55.                                 (* EIN  qErr *) QueueResult   );
  56.  
  57. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  58.  
  59.   PROCEDURE  AssignQueueHandler ((* EIN/  -- *) handler : QueueHandler );
  60.  
  61.   PROCEDURE  UnAssignQueueHandler;
  62.  
  63.  (*-------------------------------------------------------------------------
  64.   | Ist mit "AssignQueueHandler" eine Fehlerbehandlungsroutine definiert    |
  65.   | worden, so wird diese jedesmal automatisch aufgerufen, wenn bei einer   |
  66.   | Queueoperation ein Fehler aufgetreten ist; die Prozedur erhaelt als     |
  67.   | Parameter den Fehler vom Typ "QueueResult" und den Namen der Prozedur,  |
  68.   | in der der Fehler auftrat.                                              |
  69.   | Nach Programmstart oder Aufruf von "UnAssignQueueHandler" wird vom Modul|
  70.   | kein Handler beim Auftritt eines Fehlers aktiviert.                     |
  71.   |                                                                         |
  72.   | Beispiel fuer einen einfachen Handler:                                  |
  73.   |                                                                         |
  74.   | PROCEDURE Queuehandler( proc : ARRAY OF CHAR; fehler : QueueResult );   |
  75.   |   BEGIN                                                                 |
  76.   |     WriteLn;                                                            |
  77.   |     WriteString('Fehler bei Queueoperation - ');                        |
  78.   |     WriteString('Prozedur '); WriteString(proc); Write(':');            |
  79.   |     WriteLn;                                                            |
  80.   |     CASE  fehler  OF                                                    |
  81.   |      | queueOk   : WriteString('Alles ok');                             |
  82.   |      | defErr    : WriteString('Die benutzte Queue ist undefiniert!');  |
  83.   |      | sizeErr   :                                                      |
  84.   |          WriteString('Das Datenelement hat einen anderen Speicher');    |
  85.   |          WriteString('bedarf,'); WriteLn;                               |
  86.   |          WriteString('als bei der Queuedefinition angegeben.');         |
  87.   |      | noMem     : WriteString('Kein freier Speicher mehr.');           |
  88.   |      | queueEmpty: WriteString('Die Queue ist leer.');                  |
  89.   |      ELSE                                                               |
  90.   |        WriteString('Totaler Zusammenbruch...');                         |
  91.   |     END; (* CASE *)                                                     |
  92.   |     WriteLn; WriteLn;                                                   |
  93.   |   END  Queuehandler;                                                    |
  94.    -------------------------------------------------------------------------*)
  95.  
  96.  
  97.    PROCEDURE  LastQueueResult ( ): QueueResult;
  98.  
  99.  (*-------------------------------------------------------------------------
  100.   | Liefert das Resultat der letzten Queueoperation, falls <done> nicht aus-|
  101.   | reichen sollte oder fuer die Prozeduren "Length" und "IsEmpty", die     |
  102.   | keinen Erfolgsparameter <done> haben.                                   |
  103.   |                                                                         |
  104.   | Moegliche Kombinationen sind:                                           |
  105.   |  - queueOk    : Es ist kein Fehler aufgetreten. Moegliches Ergebnis     |
  106.   |                 aller Prozeduren.                                       |
  107.   |  - queueEmpty : Es wurde versucht, ein Element aus einer leeren Queue   |
  108.   |                 zu holen. Moegliches Ergebnis von "Remove" und "Look".  |
  109.   |  - noMem      : der Speicher reicht nicht fuer die Ausfuehrung von      |
  110.   |                 "Create" oder "Insert".                                 |
  111.   |  - sizeErr    : Es wurde versucht, ein Element an die Queue anzuhaengen |
  112.   |                 oder aus der Queue zu holen, das eine andere Speicher-  |
  113.   |                 platzgroesse hat, als bei der Definition des Queue ange-|
  114.   |                 geben wurde. Moegliches Ergebnis von "Insert", "Remove" |
  115.   |                 und "Look".                                             |
  116.   |  - defErr     : Es wurde versucht, eine Queueoperation mit einer unde-  |
  117.   |                 finierten Queuevariable auszufuehren. Moegliches Resul- |
  118.   |                 tat aller Prozeduren ausser "Create".                   |
  119.    -------------------------------------------------------------------------*)
  120.  
  121. (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*)
  122.  
  123.  
  124.   PROCEDURE  Create ((* EIN/ -- *)     groesse : CARDINAL;
  125.                      (* EIN/ -- *)     blkElem : CARDINAL;
  126.                      (* -- /AUS *) VAR queue   : Queue;
  127.                      (* -- /AUS *) VAR done    : BOOLEAN  );
  128.  
  129.  (*-------------------------------------------------------------------------
  130.   | Richtet eine Queue und ihre Verwaltung ein. <groesse> ist die Groesse   |
  131.   | der Elemente, die in <queue> abgelegt werden sollen. <blkElem> ist die  |
  132.   | Anzahl der Elemente, fuer die jeweils ein neuer Speicherblock angefor-  |
  133.   | dert wird. Ein grosser Wert fuer <blkElem> fuert zu geringerem Verwal-  |
  134.   | tungsaufwand, vergroessert aber den Anteil des Speichers, der die meiste|
  135.   | Zeit nicht genutzt wird.                                                |
  136.   | <grosse> = 0, <blkElem> = 0 werden auf 1 korrigiert.                    |
  137.   | Die Prozedur muss vor allen anderen Queueoperationen ausgefuehrt werden;|
  138.   | <queue> ist nur fuer Elemente der angegebenen Groesse zu benutzen.      |
  139.   | <queue> ist immer mindestens einen Speicherblock gross.                 |
  140.   |                                                                         |
  141.   | Moegliche Fehler: noMem                                                 |
  142.    -------------------------------------------------------------------------*)
  143.  
  144.  
  145.   PROCEDURE  Delete ((* EIN/AUS *) VAR queue : Queue;
  146.                      (* -- /AUS *) VAR done  : BOOLEAN );
  147.  
  148.  (*-------------------------------------------------------------------------
  149.   | Gegenstueck zu "Create": <queue> wird aus der Verwaltung entfernt, und  |
  150.   | der belegte Speicherplatz freigegeben.                                  |
  151.   | <queue> hat nach der Operation den Wert NIL.                            |
  152.   |                                                                         |
  153.   | Moegliche Fehler: defErr                                                |
  154.    -------------------------------------------------------------------------*)
  155.  
  156.  
  157.   PROCEDURE  IsEmpty ((* EIN/ -- *) VAR queue : Queue ): BOOLEAN;
  158.  
  159.  (*-------------------------------------------------------------------------
  160.   | Testet, ob <queue> leer ist.                                            |
  161.   |                                                                         |
  162.   | Moegliche Fehler: defErr                                                |
  163.    -------------------------------------------------------------------------*)
  164.  
  165.   PROCEDURE  Clear ((* EIN/AUS *) VAR queue : Queue;
  166.                     (* -- /AUS *) VAR done  : BOOLEAN );
  167.  
  168.  (*-------------------------------------------------------------------------
  169.   | Entfernt saemtliche Elemente aus <queue>, und gibt deren Speicherplatz  |
  170.   | frei; <queue> selber bleibt erhalten.                                   |
  171.   |                                                                         |
  172.   | Moegliche Fehler: defErr                                                |
  173.    -------------------------------------------------------------------------*)
  174.  
  175.  
  176.   PROCEDURE  Length ((* EIN/ -- *) VAR queue : Queue ): CARDINAL;
  177.  
  178.  (*-------------------------------------------------------------------------
  179.   | Liefert die Anzahl der Elemente in <queue>.                             |
  180.   |                                                                         |
  181.   | Moegliche Fehler: defErr                                                |
  182.    -------------------------------------------------------------------------*)
  183.  
  184.  
  185.  
  186.   PROCEDURE  Insert ((* EIN/ -- *)     wert  : ARRAY OF BYTE;
  187.                      (* EIN/AUS *) VAR queue : Queue;
  188.                      (* -- /AUS *) VAR done  : BOOLEAN       );
  189.  
  190.  (*-------------------------------------------------------------------------
  191.   | <element> wird ans Ende von <queue> angefuegt.                          |
  192.   |                                                                         |
  193.   | Moegliche Fehler: defErr, sizeErr, noMem                                |
  194.    -------------------------------------------------------------------------*)
  195.  
  196.  
  197.   PROCEDURE  Remove ((* EIN/AUS *) VAR queue : Queue;
  198.                      (* -- /AUS *) VAR wert  : ARRAY OF BYTE;
  199.                      (* -- /AUS *) VAR done  : BOOLEAN       );
  200.  
  201.  (*-------------------------------------------------------------------------
  202.   | Entfernt das erste Element von <queue>, und liefert es in <wert>.       |
  203.   | Im Fehlerfall wird <wert> auf Null gesetzt.                             |
  204.   |                                                                         |
  205.   | Moegliche Fehler: defErr, sizeErr, queueEmpty                           |
  206.    -------------------------------------------------------------------------*)
  207.  
  208.  
  209.   PROCEDURE  Look ((* EIN/ -- *) VAR queue : Queue;
  210.                    (* -- /AUS *) VAR wert  : ARRAY OF BYTE;
  211.                    (* -- /AUS *) VAR done  : BOOLEAN       );
  212.  
  213.  (*-------------------------------------------------------------------------
  214.   | Liefert das erste Element von <queue> in <wert>. <queue> wird nicht     |
  215.   | veraendert. Im Fehlerfall wird <wert> auf Null gesetzt.                 |
  216.   |                                                                         |
  217.   | Moegliche Fehler: defErr, sizeErr, queueEmpty                           |
  218.    -------------------------------------------------------------------------*)
  219.  
  220. END  Queues.
  221.